package dome2;

/*

    重写！
    重写需要注意的点：
    1、被private修饰的不能被重写！
    2.被static修饰的不能被重写！
    3.子类的访问修饰权限要大于等于父类的访问修饰权限！
    private < 默认 < protected < public
    4.被final修饰的不能重写，被final修饰的方法称为-密封方法

    注意(应当避免！)：当在父类的构造方法中，去调用父类和子类重写的方法的时候，此时会调用子类的方法

    动态绑定：是发生多态的基础
    在底层编译的时候帮我们调用的是父类的方法，但是在运行的时候帮我们调用的却是子类的方法
    动态：运行时
    1.向上转型
    2.重写
    3.通过父类的引用 调用 父类与子类重名的方法

    多态：--> 一种思想
    当父类引用所引用的对象不一样的时候，表现出的行为是不一样的。
 */





class
Animal {

    public String name;
    public int age;


    public void eat() {
        System.out.println(name+" 正在吃饭！");
    }
}

class Dog extends Animal {

    public void wangwang() {
        System.out.println(name+" 正在汪汪叫！");
    }

    @Override   //判断是否构成重写
    public void eat() {  //重写              //2
        System.out.println(name+" 正在吃狗粮！");
    }
}

class Brid extends Animal {

    public int Wing;//翅膀

    public void fly() {
        System.out.println(name + " 正在飞！");
    }

    @Override    //判断是否构成重写
    public void eat() {  //重写
        System.out.println(name+" 正在吃鸟粮！");
    }
}


public class Test1 {

    public static void funcTion(Animal animal) {

        animal.eat();
    }

    public static void main(String[] args) {

        Animal animal1 = new Dog();//1
        animal1.name = "十三月";
        funcTion(animal1); // 此时发生的就是多态思想

        System.out.println("======");

        Animal animal2 = new Brid();
        animal2.name ="圆圆";
        funcTion(animal2); // 此时发生的就是多态思想

    }

    public static void main1(String[] args) {
//经过重写之后的方法运行之后发现调用的是子类重写之后的方法  此时发生的是-> 动态绑定
        Animal animal1 = new Dog();//1
        animal1.name = "十三月";
        animal1.eat();//3    发现调用的是子类的eat

        System.out.println("======");

        Animal animal2 = new Brid();
        animal2.name ="圆圆";
        animal2.eat();
    }
}


